﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Media;
using System.Collections.ObjectModel;
using System.Data;
using System.Windows.Media.Imaging;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Controls;
using System.Globalization;
using produccion.modelo;
using produccion.AccesoDatos;
using produccion.clases;
using produccion.modulos;
using produccion.forms;
using System.Windows.Input;
using System.Collections.Specialized;
using System.Drawing.Printing;

namespace produccion.vistamodelo
{
    class VMFacturacion : ViewModelBase, IDataErrorInfo
    {
        #region Campos
            private List<MFacturacion.clientes> _lisclientes = new List<MFacturacion.clientes>();
            private List<MFacturacion.detalleOrdenes> _lisordenes = new List<MFacturacion.detalleOrdenes>();
            private CLSMAECLIP _clientes = new CLSMAECLIP();
            private ProcesoProduccionRepositorio _repositorio = new ProcesoProduccionRepositorio();
            MDOgeneral _mod = new MDOgeneral();
        #endregion

        #region constructor
            public VMFacturacion()
            {
                try
                {
                    if (MDOgeneral.conexion == null || MDOgeneral.conexion.State == ConnectionState.Closed)
                    {
                        MDOgeneral.conectar();
                    }
                    strTituloVentana = "Facturación - Usuario: " + MDOgeneral.usuario + " - [FRMFacturacion]";

                    BooClienteCambiadoManualmente = false;//FJRF - Ponemos por defecto la seleccion en falso
                    consultaClientes();
                    consultaConcepto();
                    consultaConcecFact();
                    cargarClientes();
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }
        #endregion

        #region Comandos
            RelayCommand _cmdGrabar;
            public ICommand cmdGrabar
            {
                get
                {
                    if (_cmdGrabar == null)
                    {
                        _cmdGrabar = new RelayCommand(x => grabarFactura());
                    }
                    return _cmdGrabar;
                }
            }

            RelayCommand _cmdDobleClic;
            public ICommand cmdDobleClic
            {
                get
                {
                    if (_cmdDobleClic == null)
                    {
                        _cmdDobleClic = new RelayCommand(r => dobleClic());
                    }
                    return _cmdDobleClic;
                }
            }

            RelayCommand _cmdCostear;
            public ICommand cmdCostear
            {
                get
                {
                    if (_cmdCostear == null)
                    {
                        _cmdCostear = new RelayCommand(r => costear());
                    }
                    return _cmdCostear;
                }
            }

            RelayCommand _cmdSalir2;
            public ICommand cmdSalir2
            {
                get
                {
                    if (_cmdSalir2 == null)
                    {
                        _cmdSalir2 = new RelayCommand(r => Salir2());
                    }
                    return _cmdSalir2;
                }
            }

            RelayCommand _cmdSalir;
            public ICommand cmdSalir
            {
                get
                {

                    if (_cmdSalir == null)
                    {
                        _cmdSalir = new RelayCommand(Salir);
                    }
                    return _cmdSalir;
                }
            }

            RelayCommand _cmdBuscarCliente;
            public ICommand cmdBuscarCliente
            {
                get
                {
                    if (_cmdBuscarCliente == null)
                    {
                        _cmdBuscarCliente = new RelayCommand(r => buscar_cliente());
                    }
                    return _cmdBuscarCliente;
                }
            }
        #endregion

        #region Propiedades
            private string _strTituloVentana;
            public string strTituloVentana
            {
                get { return _strTituloVentana; }
                set { _strTituloVentana = value; base.OnPropertyChanged("strTituloVentana"); }
            }

            private MDOgeneral.mensaje _msn = new MDOgeneral.mensaje();
            public MDOgeneral.mensaje msn
            {
                get { return _msn; }
                set { _msn = value; base.OnPropertyChanged("msn"); }
            }

            public List<MFacturacion.clientes> lisclientes
            {
                get { return _lisclientes; }
                set { _lisclientes = value; base.OnPropertyChanged("lisclientes"); }
            }

            public List<MFacturacion.detalleOrdenes> lisordenes
            {
                get { return _lisordenes; }
                set { _lisordenes = value; base.OnPropertyChanged("lisordenes"); }
            }

            private ObservableCollection<VMClientesPendientes> _lisclientespendientes = new ObservableCollection<VMClientesPendientes>();
            public ObservableCollection<VMClientesPendientes> lisclientespendientes
            {
                get { return _lisclientespendientes; }
                set { _lisclientespendientes = value; base.OnPropertyChanged("lisclientespendientes"); }
            }

            private VMClientesPendientes _sellisclientespendientes;
            public VMClientesPendientes sellisclientespendientes
            {
                get { return _sellisclientespendientes; }
                set 
                { 
                    _sellisclientespendientes = value;
                    if (_sellisclientespendientes != null)
                    {
                        Mouse.OverrideCursor = Cursors.Wait;

                        BooClienteCambiadoManualmente = false;//FJRF - Cada vez que pasa por aca es porque se selecciono el cliente por parte del grid

                        consultarOrdenes(_sellisclientespendientes.codcli_cli);
                        consultaCliente(_sellisclientespendientes.codcli_cli);
                        consultaConsecutivoFac();

                        Mouse.OverrideCursor = Cursors.Arrow;
                    }
                    base.OnPropertyChanged("sellisclientespendientes"); 
                }
            }

            private ObservableCollection<VMDetalleOrdenes> _lisdetalleordenes = new ObservableCollection<VMDetalleOrdenes>();
            public ObservableCollection<VMDetalleOrdenes> lisdetalleordenes
            {
                get { return _lisdetalleordenes; }
                set { _lisdetalleordenes = value; base.OnPropertyChanged("lisdetalleordenes"); }
            }

            private VMDetalleOrdenes _sellisdetalleordenes;
            public VMDetalleOrdenes sellisdetalleordenes
            {
                get { return _sellisdetalleordenes; }
                set 
                { 
                    _sellisdetalleordenes = value;
                    base.OnPropertyChanged("sellisdetalleordenes");

                    PttV_CambiarPreciosSegunClienteModificado(codcli_cli, "");//FJRF - Actualizamos los precion de todas las ordenes segun el nuevo cliente
                }
            }

            public string codcli_cli
            {
                get { return _clientes.CODCLI_CLI; }
                set 
                { 
                    _clientes.CODCLI_CLI = value; 
                    base.OnPropertyChanged("codcli_cli");
                    if (codcli_cli != null)
                    {
                        if (codcli_cli.Length == 3)
                        {
                            BooClienteCambiadoManualmente = true;//FJRF - Informamos que el cliente fue cambiado manualmente

                            consultaCliente(codcli_cli);
                        }
                        else
                            limpiaCliente();
                    }
                }
            }

            public string nomcli_cli
            {
                get { return _clientes.NOMCLI_CLI; }
                set { _clientes.NOMCLI_CLI = value; base.OnPropertyChanged("nomcli_cli"); }
            }

            public string dircli_cli
            {
                get { return _clientes.DIRCLI_CLI; }
                set { _clientes.DIRCLI_CLI = value; base.OnPropertyChanged("dircli_cli"); }
            }

            public string nitcli_cli
            {
                get { return _clientes.NITCLI_CLI; }
                set { _clientes.NITCLI_CLI = value; base.OnPropertyChanged("nitcli_cli"); }
            }

            public string tel1cli_cli
            {
                get { return _clientes.TEL1CLI_CLI; }
                set { _clientes.TEL1CLI_CLI = value; base.OnPropertyChanged("tel1cli_cli"); }
            }

            public string tel2cli_cli
            {
                get { return _clientes.TEL2CLI_CLI; }
                set { _clientes.TEL2CLI_CLI = value; base.OnPropertyChanged("tel2cli_cli"); }
            }

            public string plazo_cli
            {
                get { return _clientes.PLAZO_CLI; }
                set { _clientes.PLAZO_CLI = value; base.OnPropertyChanged("plazo_cli"); }
            }

            private string _strConceptoFac;
            public string strConceptoFac
            {
                get { return _strConceptoFac; }
                set { _strConceptoFac = value; base.OnPropertyChanged("strConceptoFac"); }
            }

            private Int32 _totalunidades=0;
            public Int32 totalunidades
            {
                get { return _totalunidades; }
                set { _totalunidades = value; base.OnPropertyChanged("totalunidades"); }
            }

            private string _nrofac_efa ;
            public string nrofac_efa
            {
                get { return _nrofac_efa; }
                set { _nrofac_efa = value; base.OnPropertyChanged("nrofac_efa"); }
            }

            private DateTime _fecfac_efa = DateTime.Now;
            public DateTime fecfac_efa
            {
                get { return _fecfac_efa; }
                set { _fecfac_efa = value; base.OnPropertyChanged("fecfac_efa"); }
            }

            private double _subtotal=0;
            public double subtotal
            {
                get { return _subtotal; }
                set { _subtotal = value; base.OnPropertyChanged("subtotal"); }
            }

            private double _dtofac_efa = 0;
            public double dtofac_efa
            {
                get { return _dtofac_efa; }
                set { _dtofac_efa = value; base.OnPropertyChanged("dtofac_efa"); }
            }

            private Int32 _numMaxFactura;
            public Int32 numMaxFactura
            {
                get { return _numMaxFactura; }
                set { _numMaxFactura = value; base.OnPropertyChanged("numMaxFactura"); }
            }

            private double _numIva;
            public double numIva
            {
                get { return _numIva; }
                set { _numIva = value; base.OnPropertyChanged("numIva"); }
            }

            private double _ivafac_efa = 0;
            public double ivafac_efa
            {
                get { return _ivafac_efa; }
                set { _ivafac_efa = value; base.OnPropertyChanged("ivafac_efa"); }
            }

            private Int32 _numBaseRetencion;
            public Int32 numBaseRetencion
            {
                get { return _numBaseRetencion; }
                set { _numBaseRetencion = value; base.OnPropertyChanged("numBaseRetencion"); }
            }

            private double _numPorcRetencion;
            public double numPorcRetencion
            {
                get { return _numPorcRetencion; }
                set { _numPorcRetencion = value; base.OnPropertyChanged("numPorcRetencion"); }
            }

            private double _rtefac_efa = 0;
            public double rtefac_efa
            {
                get { return _rtefac_efa; }
                set { _rtefac_efa = value; OnPropertyChanged("rtefac_efa"); }
            }

            private double _flete = 0;
            public double flete
            {
                get { return _flete; }
                set 
                { 
                    _flete = value;
                    valfac_efa = valfac_efa + _flete;
                    base.OnPropertyChanged("flete"); 
                }
            }

            private double _valfac_efa = 0;
            public double valfac_efa
            {
                get { return _valfac_efa; }
                set { _valfac_efa = value; base.OnPropertyChanged("valfac_efa"); }
            }

            public double numDescuento
            {
                get { return _clientes.DCTCLI_CLI; }
                set { _clientes.DCTCLI_CLI = value; base.OnPropertyChanged("numDescuento"); }
            }

            public string aplrte_cli
            {
                get { return _clientes.APLRTE_CLI; }
                set { _clientes.APLRTE_CLI = value; base.OnPropertyChanged("aplrte_cli"); }
            }

            private string _strResolucionDIAN;
            public string strResolucionDIAN
            {
                get { return _strResolucionDIAN; }
                set { _strResolucionDIAN = value; base.OnPropertyChanged("strResolucionDIAN"); }
            }

            private DataTable _dtProductos;
            public DataTable dtProductos
            {
                get { return _dtProductos; }
                set { _dtProductos = value; base.OnPropertyChanged("dtProductos"); }
            }

            private Int32 _numIndex;
            public Int32 numIndex
            {
                get { return _numIndex; }
                set { _numIndex = value; base.OnPropertyChanged("numIndex"); }
            }

            private string _strNumOrden;
            public string strNumOrden
            {
                get { return _strNumOrden; }
                set { _strNumOrden = value; base.OnPropertyChanged("strNumOrden"); }
            }

            private Boolean _IsOpenResumen = false;
            public Boolean IsOpenResumen
            {
                get { return _IsOpenResumen; }
                set { _IsOpenResumen = value; base.OnPropertyChanged("IsOpenResumen"); }
            }

            private Boolean _BooClienteCambiadoManualmente = false;//FJRF - Para saber si el cliente fue cambiado manualmente
            public Boolean BooClienteCambiadoManualmente
            {
                get { return _BooClienteCambiadoManualmente; }
                set { _BooClienteCambiadoManualmente = value; base.OnPropertyChanged("BooClienteCambiadoManualmente"); }
            }

            private string _strTipodeOrden = "P";
            public string strTipodeOrden
            {
                get { return _strTipodeOrden; }
                set 
                { 
                    _strTipodeOrden = value; 
                    base.OnPropertyChanged("strTipodeOrden");
                    consultarOrdenes(sellisclientespendientes.codcli_cli);
                }
            }

            private VMbuscarGeneral _buscarCliente;
            public VMbuscarGeneral buscarCliente
            {
                get { return _buscarCliente; }
                set { _buscarCliente = value; base.OnPropertyChanged("buscarCliente"); }
            }

        #endregion

        #region Metodos
            
            void consultaConcecFact()
            {
                try
                {
                    DataTable dt = new MFacturacion.detalleOrdenes().consultaConsecutivoFactura("A");
                    if (dt.Rows.Count > 0)
                    {
                            nrofac_efa = "00" + Convert.ToString(Convert.ToInt32(dt.Rows[0][2].ToString()) + 1);
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            public void consultaConsecutivoFac()
            {
                try
                {
                    DataTable fac = new MFacturacion.detalleOrdenes().consultaInfFactura();
                    foreach (DataRow dr in fac.Rows)
                    {
                        if (dr[0].ToString().Trim() == "NRO")
                        {
                            nrofac_efa = "00" + Convert.ToString(Convert.ToInt32(dr[2].ToString().Trim())+1);
                        }

                        if (dr[0].ToString().Trim() == "RES")
                        {
                            strResolucionDIAN = dr[2].ToString().Trim();
                        }

                        if (dr[0].ToString().Trim() == "TAR")
                        {
                            numIva = Convert.ToDouble(dr[2].ToString().Trim(), new CultureInfo("en-US"));
                        }

                        if (dr[0].ToString().Trim() == "BAS")
                        {
                            numBaseRetencion = Convert.ToInt32(dr[2].ToString().Trim());
                        }

                        if (dr[0].ToString().Trim() == "POR")
                        {
                            numPorcRetencion = Convert.ToDouble(dr[2].ToString().Trim(), new CultureInfo("en-US"));
                        }

                        if (dr[0].ToString().Trim() == "FAC")
                        {
                            numMaxFactura = Convert.ToInt32(dr[2].ToString().Trim());
                        }
                    }
                    if (numMaxFactura - Convert.ToInt32(nrofac_efa) <= 300)
                    {
                        msn.texto = "Recuerde avisar a contabilidad que solicite a la DIAN una nueva numeración.";
                        msn.tipo = false;
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            public void consultaConcepto()
            {
                try
                {
                    CLSCCPFAC cc = new CLSCCPFAC { CODCCP_CFC = "01" };
                    cc.consultar();
                    strConceptoFac = cc.CODCCP_CFC;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            private void buscar_cliente()
            {
                try
                {
                    buscarCliente.IsOpen = true;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            private void cargarClientes()
            {
                try
                {
                    List<CLSMAECLIP> lisclientes = new CLSMAECLIP().listaCliente();
                    _buscarCliente = new VMbuscarGeneral((from cli in lisclientes
                                                          select new
                                                              VMlistaGenerica { strColumna1 = cli.CODCLI_CLI, strColumna2 = cli.NOMCLI_CLI, strColumna3 = cli.NITCLI_CLI }).ToList());
                    buscarCliente.PropertyChanged += onBuscarClientePropertyChanged;
                    buscarCliente.gridBuscar.columna1.strNombre = "Código";
                    buscarCliente.gridBuscar.columna2.strNombre = "Nombre                       ";
                    buscarCliente.gridBuscar.columna3.strNombre = "Nit           ";
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            void onBuscarClientePropertyChanged(object sender, PropertyChangedEventArgs e)
            {
                try
                {
                    if (e.PropertyName == "IsOpen")
                    {
                        if (!buscarCliente.IsOpen)
                        {
                            if (buscarCliente.gridBuscar.selLista != null)
                            {
                                codcli_cli = buscarCliente.gridBuscar.selLista.strColumna1;
                                consultaCliente(codcli_cli);
                            }
                        }
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            private void limpiaCliente()
            {
                try
                {
                    nomcli_cli = null;
                    dircli_cli = null;
                    nitcli_cli = null;
                    tel1cli_cli = null;
                    tel2cli_cli = null;
                    plazo_cli = null;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }
            
            public void consultaCliente(string strCliente)
            {
                try
                {
                    CLSMAECLIP lc = new CLSMAECLIP { CODCLI_CLI = strCliente };
                    lc.consultar();
                    _clientes = lc;
                    if (lc.EXISTE == false)
                    {
                        limpiaCliente();
                        msn.texto = "El cliente ingresado no existe.";
                        msn.tipo = false;
                    }
                    base.OnPropertyChanged("codcli_cli");
                    base.OnPropertyChanged("nomcli_cli");
                    base.OnPropertyChanged("dircli_cli");
                    base.OnPropertyChanged("nitcli_cli");
                    base.OnPropertyChanged("tel1cli_cli");
                    base.OnPropertyChanged("tel2cli_cli");
                    base.OnPropertyChanged("plazo_cli");

                    PttV_CambiarPreciosSegunClienteModificado(strCliente, "");//FJRF - Cambiamos los precios del nuevo cliente
                }
                catch (Exception ex) 
                { 
                    MessageBox.Show(ex.Message); 
                }
            }
            protected void PttV_CambiarPreciosSegunClienteModificado(String StrNuevoCodigoDeCliente, String StrHabilitarNumeroDeOrden)
            {
                if (BooClienteCambiadoManualmente == true)
                {
                    try//FJRF - Creamos un manejador de errores
                    {
                        String StrCodigoClienteAnterior = "", StrCodigoClienteNuevo = "", StrNumeroOrden = "", StrSePuedoContinuar = "N", StrValorRetornado = "0";//FJRF - Creamos las variables que necesitamos para este proceso cargandolas con valores por defecto
                        Boolean BooOrdenSeleccionada = false;//FJRF - Creamos las variables que necesitamos para este proceso cargandolas con valores por defecto

                        StrCodigoClienteNuevo = StrNuevoCodigoDeCliente;//FJRF - Enviamos el nuevo codigo de cliente
                        for (int IntFilaActual = 0; IntFilaActual < lisdetalleordenes.Count(); IntFilaActual++)//FJRF - Recorremos el detalle de las ordenes
                        {
                            StrCodigoClienteAnterior = lisdetalleordenes[IntFilaActual].codcli_eod;//FJRF - Extraemos el Codigo del cliente anterior
                            StrNumeroOrden = lisdetalleordenes[IntFilaActual].nroord_eod;//FJRF - Extraemos el numero de la orden

                            if (String.IsNullOrEmpty(StrNumeroOrden) == false)//FJRF - Si tiene datos hacemos lo siguiente
                            {
                                if (StrHabilitarNumeroDeOrden == StrNumeroOrden)//FJRF - miramos si las ordenes consultadas es igual a la digitada y entonces hacemos lo siguiente
                                {
                                    lisdetalleordenes[IntFilaActual].logincluir = true;//FJRF - Habilitamos la orden
                                }
                            }

                            BooOrdenSeleccionada = lisdetalleordenes[IntFilaActual].logincluir;//FJRF - Miramos si la orden esta seleccionada

                            if (BooOrdenSeleccionada == true)//FJRF - Si esta seleccionada hacemos lo siguiente
                            {
                                SP_ACTPRECIOORDENOTROCLIENTE(StrCodigoClienteNuevo, StrNumeroOrden);//FJRF - Ejecutamos el Sp que cambia el precio de las ordenes con el nuevo cliente

                                StrSePuedoContinuar = MDOgeneral.spComando.Parameters["pva_result"].Value.ToString();//FJRF - Miramos si se puede seguir
                                StrValorRetornado = MDOgeneral.spComando.Parameters["pva_errusu"].Value.ToString();//FJRF - Ponemos el nuevo precio retornado

                                if (StrSePuedoContinuar == "S")//FJRF - Si se puede continuar hacemos lo siguiente
                                {
                                    lisdetalleordenes[IntFilaActual].valortotal = Double.Parse(StrValorRetornado);//FJRF - Asignamos el nuevo valor retornado
                                    lisdetalleordenes[IntFilaActual].strDescripcion = "";//FJRF - Borramos cualquier mensaje que pueda existir
                                }
                                else//FJRF -si no se puede continuar hacemos lo siguiente
                                {
                                    lisdetalleordenes[IntFilaActual].valortotal = 0;//FJRF - Asignamos el nuevo valor retornado
                                    lisdetalleordenes[IntFilaActual].strDescripcion = "Esta Orden tiene items sin precio";//FJRF - Informamos al usuario que no tiene la lista de precios actualizada
                                    lisdetalleordenes[IntFilaActual].logincluir = false;//FJRF - quitamos la opcion seleccionada
                                    lisdetalleordenes[IntFilaActual].logFacturar = false;//FJRF - ponemos el objeto no editable
                                }
                            }
                        }
                        calcularValor();
                    }
                    catch (Exception ErrorSp) //FJRF - Si existe algun error hacemos lo siguiente
                    {
                        MessageBox.Show(ErrorSp.Message); //FJRF - Le enviamos un mensaje al usuario
                    }
                }
            }
            protected void SP_ACTPRECIOORDENOTROCLIENTE(string strCliente, string strOrden)
            {
                try
                {
                    MDOgeneral.spComando.CommandText = "SP_ACTPRECIOORDENOTROCLIENTE";
                    MDOgeneral.spComando.Connection = MDOgeneral.conexion;
                    MDOgeneral.spComando.CommandType = CommandType.StoredProcedure;
                    MDOgeneral.spComando.Parameters.Clear();

                    //Input
                    MDOgeneral.spComando.Parameters.Add("pva_codcli", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strCliente;
                    MDOgeneral.spComando.Parameters["pva_codcli"].Direction = ParameterDirection.Input;

                    MDOgeneral.spComando.Parameters.Add("pva_nroord", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strOrden;
                    MDOgeneral.spComando.Parameters["pva_nroord"].Direction = ParameterDirection.Input;

                    //Output
                    MDOgeneral.spComando.Parameters.Add("pva_result", Oracle.DataAccess.Client.OracleDbType.Varchar2, 2000).Direction = ParameterDirection.Output;
                    MDOgeneral.spComando.Parameters.Add("pva_errusu", Oracle.DataAccess.Client.OracleDbType.Varchar2, 2000).Direction = ParameterDirection.Output;
                    MDOgeneral.spComando.ExecuteNonQuery();
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }


            public void consultaClientes()
            {
                try
                {
                    lisclientes = new MFacturacion.clientes().consultar();
                    List<VMClientesPendientes> all = (from cli in lisclientes select new VMClientesPendientes(cli)).ToList();
                    Int32 numContador=0;
                    foreach (VMClientesPendientes cl in all)
                    {
                        numContador++;
                    }
                    lisclientespendientes = new ObservableCollection<VMClientesPendientes>(all);
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            public void consultarOrdenes(string strCliente)
            {
                try
                {
                    Boolean logCreaServyRep = _repositorio.crearOrdenesdeServicioyReparacion(strCliente);
                    MFacturacion.detalleOrdenes det = new MFacturacion.detalleOrdenes { CODCLI_EOD = strCliente };
                    lisordenes = det.consultar();
                    List<VMDetalleOrdenes> all = (from detord in lisordenes where detord.strTipoOrden.Equals(strTipodeOrden) select new VMDetalleOrdenes(detord, calcularValor)).ToList();
                    Int32 numContador=0;
                    foreach (VMDetalleOrdenes d in all)
                    {
                        d.PropertyChanged += OnVMDOPropertyChanged;
                        if (!String.IsNullOrEmpty(d.strDescripcion))
                        {
                            d.logFacturar = false;
                            actualizarOrdenes(strCliente, " ");
                        }
                        numContador++;
                    }
                    lisdetalleordenes = new ObservableCollection<VMDetalleOrdenes>(all);
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }
            
            void actualizarOrdenes(string strCliente, string strOrden)
            {
                try
                {
                    MDOgeneral.spComando.CommandText = "SP_ACTPRECIOORDEN";
                    MDOgeneral.spComando.Connection = MDOgeneral.conexion;
                    MDOgeneral.spComando.CommandType = CommandType.StoredProcedure;
                    MDOgeneral.spComando.Parameters.Clear();

                    //Input
                    MDOgeneral.spComando.Parameters.Add("pva_codcli", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strCliente;
                    MDOgeneral.spComando.Parameters["pva_codcli"].Direction = ParameterDirection.Input;

                    MDOgeneral.spComando.Parameters.Add("pva_nroord", Oracle.DataAccess.Client.OracleDbType.Varchar2, 40).Value = strOrden;
                    MDOgeneral.spComando.Parameters["pva_nroord"].Direction = ParameterDirection.Input;

                    //Output
                    MDOgeneral.spComando.Parameters.Add("pva_resul", Oracle.DataAccess.Client.OracleDbType.Varchar2, 2000).Direction = ParameterDirection.Output;
                    MDOgeneral.spComando.Parameters.Add("pva_errusu", Oracle.DataAccess.Client.OracleDbType.Varchar2, 2000).Direction = ParameterDirection.Output;
                    MDOgeneral.spComando.ExecuteNonQuery();
                    string c = MDOgeneral.spComando.Parameters["pva_errusu"].Value.ToString();
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            void dobleClic()
            {
                try
                {
                    if (sellisdetalleordenes != null)
                    {
                        if (!String.IsNullOrEmpty(sellisdetalleordenes.strDescripcion))
                        {
                            strNumOrden = sellisdetalleordenes.nroord_eod;
                            dtProductos = new MFacturacion.detalleOrdenes().consultaOrdenItemSinPrecio(strNumOrden);
                            IsOpenResumen = true;
                            base.OnPropertyChanged("dtProductos");
                            base.OnPropertyChanged("strNumOrden");
                        }
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            void costear()
            {
                try
                {
                    if (dtProductos.Rows.Count > 0)
                    {
                        if (numIndex != -1)
                        {
                            if (dtProductos.Rows[numIndex]["CODREF_DOD"].ToString().Length == 4)
                            {
                                IsOpenResumen = false;
                                FRMmanPreRef frm = new FRMmanPreRef();
                                frm.texCod.Text = dtProductos.Rows[numIndex]["CODREF_DOD"].ToString();
                                frm.ShowDialog();

                                if (BooClienteCambiadoManualmente == false)//FJRF - Si se selecciono por medio del grid de arriba hacemos lo siguiente
                                {
                                    actualizarOrdenes(sellisclientespendientes.codcli_cli, sellisdetalleordenes.nroord_eod);//FJRF - Lo dejamos tal como estaba
                                }
                                else//FJRF - Si ya hay un dato que se modifico manualmente hacemos lo siguiente
                                {
                                    PttV_CambiarPreciosSegunClienteModificado(codcli_cli, sellisdetalleordenes.nroord_eod);//FJRF - Actualizamos los precion de todas las ordenes segun el nuevo cliente
                                }

                                IsOpenResumen = true;
                            }
                        }
                        else
                        {
                            IsOpenResumen = false;
                            MessageBox.Show("Debe seleccionar una referencia para ponerle precio.", "Falta Seleccionar", MessageBoxButton.OK, MessageBoxImage.Error, MessageBoxResult.OK);
                            IsOpenResumen = true;
                        }
                    }
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            public void grabarFactura()
            {
                try
                {
                    Mouse.OverrideCursor = Cursors.Wait;

                    // Se captura la impresora por defecto
                    string strImpresora="";
                    foreach (string strPrinter in PrinterSettings.InstalledPrinters)
                    {
                        PrinterSettings a = new PrinterSettings();
                        a.PrinterName = strPrinter.ToString();
                        if (a.IsDefaultPrinter)
                        {
                            strImpresora = a.PrinterName ;
                        }
                    }
                    
                    //var imp = new ImprimirFactura();
                    //string strMensaje = "";
                    //imp.ImprimirDatos("43788", "PDFCreator", out strMensaje);
                    //PDFCreator FS-3140MFP+


                    DateTime dtmVence = DateTime.Now.Date;
                    if (Convert.ToInt32(plazo_cli) > 0)
                        dtmVence = Convert.ToDateTime(fecfac_efa).Date.AddDays(Convert.ToInt16(plazo_cli));
                    else
                        dtmVence = Convert.ToDateTime(fecfac_efa).Date;

                    List<MFacturacion.detalleOrdenes> lstAgregar = (from det in lisdetalleordenes where det.logincluir.Equals(true) select det.getOrdenes()).ToList();

                    consultaConcecFact();

                    if (_repositorio.guardarFactura(nrofac_efa, codcli_cli, fecfac_efa, dtmVence, valfac_efa, numPorcRetencion, rtefac_efa, numIva, ivafac_efa, dtofac_efa, flete, strConceptoFac, lstAgregar))
                    {
                        msn.texto = "La factura se guardo con exito.";
                        msn.tipo = true;
                        // Se imprime la factura
                        var imp = new ImprimirFactura();
                        string strMensaje = "";
                        imp.ImprimirDatos(nrofac_efa, strImpresora, out strMensaje, 2, false, false);
                        //PDFCreator FS-3140MFP+
                        consultaClientes();
                        lisdetalleordenes.Clear();
                        limpiarVar();
                    }
                    else
                    {
                        msn.texto = "La información de facturación no se pudo grabar.";
                        msn.tipo = false;
                    }

                    Mouse.OverrideCursor = Cursors.Arrow;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            void OnVMDOPropertyChanged(object sender, PropertyChangedEventArgs e)
            {
                (sender as VMDetalleOrdenes).VerifyPropertyName("logincluir");
                if (e.PropertyName == "logincluir") { calcularValor(); }
            }

            string calcularValor()
            {
                try
                {
                    totalunidades = (from det in lisdetalleordenes where det.logincluir.Equals(true) select det.totalarticulos).Sum();

                    subtotal = (from det in lisdetalleordenes where det.logincluir.Equals(true) select det.valortotal).Sum();

                    if (numIva > 0)
                    {
                        ivafac_efa = Math.Round((numIva / 100) * subtotal);
                    }

                    if (numDescuento > 0)
                    {
                        dtofac_efa = Math.Round(((100 - numDescuento) / 100) * subtotal);
                    }

                    if (aplrte_cli == "S" && subtotal >= numBaseRetencion && numBaseRetencion > 0)
                    {
                        rtefac_efa = Math.Round((numPorcRetencion / 100) * subtotal);
                    }
                    else
                        rtefac_efa = 0;

                    valfac_efa = (subtotal + ivafac_efa - rtefac_efa + flete - dtofac_efa);

                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return null;
            }

            private void limpiarVar()
            {
                try
                {
                    totalunidades = 0;
                    subtotal = 0;
                    dtofac_efa = 0;
                    ivafac_efa = 0;
                    rtefac_efa = 0;
                    flete = 0;
                    valfac_efa = 0;
                    consultaConcecFact();
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }
    
            public void Salir(object frmFormulario)
            {
                try
                {
                    ((Window)frmFormulario).Close();
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
            }

            public void Salir2()
            {
                IsOpenResumen = false;
                consultarOrdenes(sellisclientespendientes.codcli_cli);
                numIndex = 0;
            }

        #endregion

        #region IDataErrorInfo Members

        string IDataErrorInfo.Error { get { return null; } }

        string IDataErrorInfo.this[string propertyName]
        {
            get { return this.GetValidationError(propertyName); }
        }

        #endregion

        #region Validation

            /// <summary>
            /// Returns true if this object has no validation errors.
            /// </summary>
            /// 

            public bool IsValid
            {
                get
                {
                    foreach (string property in ValidatedProperties)
                        if (GetValidationError(property) != null)
                            return false;

                    return true;
                }
            }

            static readonly string[] ValidatedProperties = 
            { 
                "nrofac_efa",
                "totalunidades",
                "valfac_efa",
                "codcli_cli"
            };

            string GetValidationError(string propertyName)
            {
                if (Array.IndexOf(ValidatedProperties, propertyName) < 0)
                    return null;

                string error = null;

                switch (propertyName)
                {
                    case "nrofac_efa":
                        error = this.ValidateFactura();
                        break;
                    case "totalunidades":
                        error = this.ValidateUnidades();
                        break;
                    case "valfac_efa":
                        error = this.ValidateValor();
                        break;
                    case "codcli_cli":
                        error = this.ValidateCliente();
                        break;
                    default:
                        Debug.Fail("Unexpected property being validated on Customer: " + propertyName);
                        break;
                }
                return error;
            }

            string ValidateFactura()
            {
                try
                {
                    if (nrofac_efa == null) { return "Informar a sistemas que no se encontro un número disponible para facturar."; }
                    if (Convert.ToInt32(nrofac_efa.Trim()) < 1) { return "Inconsistencia al buscar el consecutivo de facturas."; }
                    return null;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return null;
            }

            string ValidateUnidades()
            {
                try
                {
                    if (totalunidades < 1) { return "Inconsistencia en la cantidad de unidades a facturar."; }
                    return null;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return null;
            }

            string ValidateValor()
            {
                try
                {
                    if (valfac_efa < 1) { return "Inconsistencia en el valor a facturar."; }
                    return null;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return null;
            }

            string ValidateCliente()
            {
                try
                {
                    if (codcli_cli == null) { return "Falta ingresar un cliente."; }
                    if (codcli_cli.Length==0) { return "Falta ingresar un cliente."; }
                    if (codcli_cli.Length==3) 
                    { 
                        if (nomcli_cli == null)    
                            return "Cliente no existe."; 
                        if (nomcli_cli.Length==0)
                            return "Cliente no existe."; 
                    }
                    return null;
                }
                catch (Exception ex) { MessageBox.Show(ex.Message); }
                return null;
            }

        #endregion

    }

    #region Vista-modelo Clientes
    public class VMClientesPendientes : ViewModelBase
    {
        #region Campos
            private MFacturacion.clientes _clientes = new MFacturacion.clientes();
        #endregion

        #region Constructor
            public VMClientesPendientes(MFacturacion.clientes clientes)
            {
                _clientes = clientes;
            }
        #endregion

        #region Metodos
            public MFacturacion.clientes getClientes()
            {
                return _clientes;
            }
        #endregion

        #region Propiedades
            public string codcli_cli
            {
                get { return _clientes.CODCLI_CLI; }
                set { _clientes.CODCLI_CLI = value; base.OnPropertyChanged("codcli_cli"); }
            }

            public string nomcli_cli
            {
                get { return _clientes.NOMCLI_CLI; }
                set { _clientes.NOMCLI_CLI = value; base.OnPropertyChanged("nomcli_cli"); }
            }

            public Int32 nroordenes
            {
                get { return _clientes.NROORDENES; }
                set { _clientes.NROORDENES = value; base.OnPropertyChanged("nroordenes"); }
            }

            public double totalarticulos
            {
                get { return _clientes.TOTARTICULOS; }
                set { _clientes.TOTARTICULOS = value; base.OnPropertyChanged("totalarticulos"); }
            }

            public double valortotal
            {
                get { return _clientes.VALORTOTAL; }
                set { _clientes.VALORTOTAL = value; base.OnPropertyChanged("valortotal"); }
            }
        #endregion
    }
    #endregion

    #region Vista-modelo Ordenes
    public class VMDetalleOrdenes : ViewModelBase
    {
        #region Campos
            private MFacturacion.detalleOrdenes _ordenes = new MFacturacion.detalleOrdenes();
        #endregion

        #region Constructor
            public VMDetalleOrdenes(MFacturacion.detalleOrdenes ordenes, DetalleModificado _detalleModificado)
            {
                _ordenes = ordenes;
                detalleModificado += _detalleModificado;
            }
        #endregion

        #region Metodos
            public MFacturacion.detalleOrdenes getOrdenes()
            {
                return _ordenes;
            }

            public delegate string DetalleModificado();

        #endregion

        #region Propiedades

            public DetalleModificado detalleModificado { get; set; }

            public string nroord_eod
            {
                get { return _ordenes.NROORD_EOD; }
                set { _ordenes.NROORD_EOD = value; base.OnPropertyChanged("nroord_eod"); }
            }

            public string fecord_eod
            {
                get { return _ordenes.FECORD_EOD; }
                set { _ordenes.FECORD_EOD = value; base.OnPropertyChanged("fecord_eod"); }
            }

            public Int32 totalarticulos
            {
                get { return _ordenes.TOTARTICULOS; }
                set { _ordenes.TOTARTICULOS = value; base.OnPropertyChanged("totalarticulos"); }
            }

            public double valortotal
            {
                get { return _ordenes.VALORTOTAL; }
                set { _ordenes.VALORTOTAL = value; base.OnPropertyChanged("valortotal"); }
            }

            public bool logincluir
            {
                get { return _ordenes.logIncluir; }
                set 
                { 
                    _ordenes.logIncluir = value;
                    base.OnPropertyChanged("logincluir");
                }
            }

            public string codcli_eod
            {
                get { return _ordenes.CODCLI_EOD; }
                set { _ordenes.CODCLI_EOD = value; base.OnPropertyChanged("codcli_eod"); }
            }

            public string strDescripcion
            {
                get { return _ordenes.strDescripcion; }
                set { _ordenes.strDescripcion = value; base.OnPropertyChanged("strDescripcion"); }
            }

            public bool logFacturar
            {
                get { return _ordenes.logFacturar; }
                set { _ordenes.logFacturar = value; base.OnPropertyChanged("logFacturar"); }
            }

            public string strTipoOrden
            {
                get { return _ordenes.strTipoOrden; }
                set { _ordenes.strTipoOrden = value; base.OnPropertyChanged("strTipoOrden"); }
            }

            public Int32 numPedido
            {
                get { return _ordenes.numPedido; }
                set { _ordenes.numPedido = value; base.OnPropertyChanged("numPedido"); }
            }
        #endregion
    }
    #endregion
}
